return FALSE;
}
+static void
+add_size (gpointer key,
+ gpointer value,
+ gpointer user_data)
+{
+ gint **res_p = user_data;
+
+ **res_p = GPOINTER_TO_INT (key);
+
+ *res_p++;
+}
+
+/**
+ * gtk_icon_theme_get_icon_sizes:
+ * @icon_theme: a #GtkIconTheme
+ * @icon_name: the name of an icon
+ *
+ * Returns an array of integers describing the sizes at which
+ * the icon is available without scaling. A size of -1 means
+ * that the icon is available in a scalable format. The array
+ * is zero-terminated.
+ *
+ * Return value: An newly allocated array describing the sizes at
+ * which the icon is available.
+ *
+ * Since: 2.6
+ **/
+gint *
+gtk_icon_theme_get_icon_sizes (GtkIconTheme *icon_theme,
+ const char *icon_name)
+{
+ GList *l, *d;
+ GHashTable *sizes;
+ gint *result;
+ guint suffix;
+
+ GtkIconThemePrivate *priv;
+
+ g_return_val_if_fail (GTK_IS_ICON_THEME (icon_theme), FALSE);
+
+ priv = icon_theme->priv;
+
+ ensure_valid_themes (icon_theme);
+
+ sizes = g_hash_table_new (g_direct_hash, g_direct_equal);
+
+ for (l = priv->themes; l; l = l->next)
+ {
+ IconTheme *theme = l->data;
+ for (d = theme->dirs; d; d = d->next)
+ {
+ IconThemeDir *dir = d->data;
+
+ suffix = GPOINTER_TO_UINT (g_hash_table_lookup (dir->icons, icon_name));
+ if (suffix != ICON_SUFFIX_NONE)
+ {
+ if (suffix == ICON_SUFFIX_SVG)
+ g_hash_table_insert (sizes, GINT_TO_POINTER (-1), NULL);
+ else
+ g_hash_table_insert (sizes, GINT_TO_POINTER (dir->size), NULL);
+ }
+ }
+ }
+
+ result = g_new0 (gint, g_hash_table_size (sizes) + 1);
+
+ g_hash_table_foreach (sizes, add_size, &result);
+ g_hash_table_destroy (sizes);
+
+ return result;
+}
static void
add_key_to_hash (gpointer key,
*
* Renders an icon previously looked up in an icon theme using
* gtk_icon_theme_lookup_icon(); the size will be based on the size
- * pssed to gtk_icon_theme_lookup_icon(). Note that the resulting
+ * passed to gtk_icon_theme_lookup_icon(). Note that the resulting
* pixbuf may not be exactly this size; an icon theme may have icons
* that differ slightly from their nominal sizes, and in addition GTK+
* will avoid scaling icons that it considers sufficiently close to the
#include "gtkkeyhash.h"
#include "gtkmain.h"
#include "gtkiconfactory.h"
+#include "gtkicontheme.h"
#include "gtkintl.h"
#include "gtkmarshalers.h"
#include "gtkplug.h"
PROP_DEFAULT_HEIGHT,
PROP_DESTROY_WITH_PARENT,
PROP_ICON,
+ PROP_ICON_NAME,
PROP_SCREEN,
PROP_TYPE_HINT,
PROP_SKIP_TASKBAR_HINT,
GList *icon_list;
GdkPixmap *icon_pixmap;
GdkPixmap *icon_mask;
+ gchar *icon_name;
guint realized : 1;
guint using_default_icon : 1;
guint using_parent_icon : 1;
+ guint using_themed_icon : 1;
} GtkWindowIconInfo;
typedef struct {
gint height,
gboolean is_geometry);
+static void update_themed_icon (GtkIconTheme *theme,
+ GtkWindow *window);
+static GList *icon_list_from_theme (GtkWidget *widget,
+ const gchar *name);
static void gtk_window_realize_icon (GtkWindow *window);
static void gtk_window_unrealize_icon (GtkWindow *window);
static GtkBinClass *parent_class = NULL;
static guint window_signals[LAST_SIGNAL] = { 0 };
static GList *default_icon_list = NULL;
+static gchar *default_icon_name = NULL;
static guint default_icon_serial = 0;
static gboolean disable_startup_notification = FALSE;
static gboolean sent_startup_notification = FALSE;
GDK_TYPE_PIXBUF,
G_PARAM_READWRITE));
+ /**
+ * GtkWindow:icon-name:
+ *
+ * The :icon-name property specifies the name of the themed icon to
+ * use as the window icon. See #GtkIconTheme for more details.
+ *
+ * Since: 2.6
+ */
+ g_object_class_install_property (gobject_class,
+ PROP_ICON_NAME,
+ g_param_spec_string ("icon_name",
+ P_("Icon Name"),
+ P_("Name of the themed icon for this window"),
+ NULL,
+ G_PARAM_READWRITE));
+
g_object_class_install_property (gobject_class,
PROP_SCREEN,
g_param_spec_object ("screen",
gtk_window_set_icon (window,
g_value_get_object (value));
break;
+ case PROP_ICON_NAME:
+ gtk_window_set_icon_name (window, g_value_get_string (value));
+ break;
case PROP_SCREEN:
gtk_window_set_screen (window, g_value_get_object (value));
break;
case PROP_ICON:
g_value_set_object (value, gtk_window_get_icon (window));
break;
+ case PROP_ICON_NAME:
+ g_value_set_string (value, gtk_window_get_icon_name (window));
+ break;
case PROP_SCREEN:
g_value_set_object (value, window->screen);
break;
"gtk-window-icon-info");
}
+static void
+free_icon_info (GtkWindowIconInfo *info)
+{
+ g_free (info->icon_name);
+ g_free (info);
+}
+
+
static GtkWindowIconInfo*
ensure_icon_info (GtkWindow *window)
{
g_object_set_data_full (G_OBJECT (window),
"gtk-window-icon-info",
info,
- g_free);
+ (GDestroyNotify)free_icon_info);
}
return info;
}
}
+static GList *
+icon_list_from_theme (GtkWidget *widget,
+ const gchar *name)
+{
+ GList *list;
+
+ GtkIconTheme *icon_theme;
+ GdkPixbuf *icon;
+ gint *sizes;
+ gint i;
+
+ icon_theme = gtk_icon_theme_get_for_screen (gtk_widget_get_screen (widget));
+
+ sizes = gtk_icon_theme_get_icon_sizes (icon_theme, name);
+ list = NULL;
+
+ for (i = 0; sizes[i]; i++)
+ {
+ /* FIXME
+ * We need an EWMH extension to handle scalable icons
+ * by passing their name to the WM. For now just use a
+ * fixed size of 48.
+ */
+ if (sizes[i] == -1)
+ icon = gtk_icon_theme_load_icon (icon_theme, name,
+ 48, 0, NULL);
+ else
+ icon = gtk_icon_theme_load_icon (icon_theme, name,
+ sizes[i], 0, NULL);
+ if (icon)
+ list = g_list_append (list, icon);
+ }
+
+ return list;
+}
+
+
static void
gtk_window_realize_icon (GtkWindow *window)
{
GtkWidget *widget;
GtkWindowIconInfo *info;
GList *icon_list;
-
+
widget = GTK_WIDGET (window);
g_return_if_fail (widget->window != NULL);
info->using_default_icon = FALSE;
info->using_parent_icon = FALSE;
+ info->using_themed_icon = FALSE;
icon_list = info->icon_list;
-
+
+ /* Look up themed icon */
+ if (icon_list == NULL && info->icon_name)
+ {
+ icon_list = icon_list_from_theme (widget, info->icon_name);
+ info->using_themed_icon = TRUE;
+ }
+
/* Inherit from transient parent */
if (icon_list == NULL && window->transient_parent)
{
if (icon_list)
info->using_default_icon = TRUE;
}
+
+ /* Look up themed icon */
+ if (icon_list == NULL && default_icon_name)
+ {
+ icon_list = icon_list_from_theme (widget, default_icon_name);
+ info->using_default_icon = TRUE;
+ info->using_themed_icon = TRUE;
+ }
gdk_window_set_icon_list (widget->window, icon_list);
info->icon_mask);
info->realized = TRUE;
+
+ if (info->using_themed_icon)
+ {
+ GtkIconTheme *icon_theme;
+
+ g_list_foreach (icon_list, (GFunc) g_object_unref, NULL);
+ g_list_free (icon_list);
+
+ icon_theme = gtk_icon_theme_get_for_screen (gtk_widget_get_screen (GTK_WIDGET (window)));
+ g_signal_connect (icon_theme, "changed",
+ G_CALLBACK (update_themed_icon), window);
+ }
}
static void
info->icon_pixmap = NULL;
info->icon_mask = NULL;
+ if (info->using_themed_icon)
+ {
+ GtkIconTheme *icon_theme;
+
+ icon_theme = gtk_icon_theme_get_for_screen (gtk_widget_get_screen (GTK_WIDGET (window)));
+
+ g_signal_handlers_disconnect_by_func (icon_theme, update_themed_icon, window);
+ }
+
/* We don't clear the properties on the window, just figure the
* window is going away.
*/
info->realized = FALSE;
+
}
/**
g_list_free (list);
}
+
+static void
+update_themed_icon (GtkIconTheme *icon_theme,
+ GtkWindow *window)
+{
+ g_object_notify (G_OBJECT (window), "icon");
+
+ gtk_window_unrealize_icon (window);
+
+ if (GTK_WIDGET_REALIZED (window))
+ gtk_window_realize_icon (window);
+}
+
+/**
+ * gtk_window_set_icon_name:
+ * @window: a #GtkWindow
+ * @name: the name of the themed icon
+ *
+ * Sets the icon for the window from a named themed icon. See
+ * the docs for #GtkIconTheme for more details.
+ *
+ * Note that this has nothing to do with the WM_ICON_NAME
+ * property which is mentioned in the ICCCM.
+ *
+ * Since: 2.6
+ */
+void
+gtk_window_set_icon_name (GtkWindow *window,
+ const gchar *name)
+{
+ GtkWindowIconInfo *info;
+ gchar *tmp;
+
+ g_return_if_fail (GTK_IS_WINDOW (window));
+
+ info = ensure_icon_info (window);
+
+ tmp = info->icon_name;
+ info->icon_name = g_strdup (name);
+ g_free (tmp);
+
+ g_list_foreach (info->icon_list, (GFunc) g_object_unref, NULL);
+ g_list_free (info->icon_list);
+
+ update_themed_icon (NULL, window);
+
+ g_object_notify (G_OBJECT (window), "icon_name");
+}
+
+/**
+ * gtk_window_get_icon_name:
+ * @window: a #GtkWindow
+ *
+ * Returns the name of the themed icon for the window,
+ * see gtk_window_set_icon_name().
+ *
+ * Returns: the icon name or %NULL if the window has
+ * no themed icon
+ *
+ * Since: 2.6
+ */
+G_CONST_RETURN gchar *
+gtk_window_get_icon_name (GtkWindow *window)
+{
+ GtkWindowIconInfo *info;
+
+ g_return_val_if_fail (GTK_IS_WINDOW (window), NULL);
+
+ info = ensure_icon_info (window);
+
+ return info->icon_name;
+}
+
/**
* gtk_window_get_icon:
* @window: a #GtkWindow
g_list_free (list);
}
+/**
+ * gtk_window_set_default_icon_name:
+ * @name: the name of the themed icon
+ *
+ * Sets an icon to be used as fallback for windows that haven't
+ * had gtk_window_set_icon_list() called on them from a named
+ * themed icon, see gtk_window_set_icon_name().
+ *
+ * Since: 2.6
+ **/
+void
+gtk_window_set_default_icon_name (const gchar *name)
+{
+ GList *tmp_list;
+ GList *toplevels;
+
+ /* Update serial so we don't used cached pixmaps/masks
+ */
+ default_icon_serial++;
+
+ g_free (default_icon_name);
+ default_icon_name = g_strdup (name);
+
+ g_list_foreach (default_icon_list,
+ (GFunc) g_object_unref, NULL);
+
+ g_list_free (default_icon_list);
+ default_icon_list = NULL;
+
+ /* Update all toplevels */
+ toplevels = gtk_window_list_toplevels ();
+ tmp_list = toplevels;
+ while (tmp_list != NULL)
+ {
+ GtkWindowIconInfo *info;
+ GtkWindow *w = tmp_list->data;
+
+ info = get_icon_info (w);
+ if (info && info->using_default_icon && info->using_themed_icon)
+ {
+ gtk_window_unrealize_icon (w);
+ if (GTK_WIDGET_REALIZED (w))
+ gtk_window_realize_icon (w);
+ }
+
+ tmp_list = tmp_list->next;
+ }
+ g_list_free (toplevels);
+}
+
/**
* gtk_window_set_default_icon_from_file:
* @filename: location of icon file
projects / gtk4.git / commitdiff